// Copyright 2019 Google LLC.
#ifndef Paragraph_DEFINED
#define Paragraph_DEFINED

#include "include/core/SkPath.h"
#include "modules/skparagraph/include/FontCollection.h"
#include "modules/skparagraph/include/Metrics.h"
#include "modules/skparagraph/include/ParagraphStyle.h"
#include "modules/skparagraph/include/TextStyle.h"
#include <unordered_set>

class SkCanvas;

namespace skia {
namespace textlayout {
class ParagraphPainter;

class Paragraph {
public:
    Paragraph(ParagraphStyle style, sk_sp<FontCollection> fonts);

    virtual ~Paragraph() = default;

    SkScalar getMaxWidth()
    {
        return fWidth;
    }

    SkScalar getHeight()
    {
        return fHeight;
    }

    SkScalar getMinIntrinsicWidth()
    {
        return fMinIntrinsicWidth;
    }

    SkScalar getMaxIntrinsicWidth()
    {
        return fMaxIntrinsicWidth;
    }

    SkScalar getAlphabeticBaseline()
    {
        return fAlphabeticBaseline;
    }

    SkScalar getIdeographicBaseline()
    {
        return fIdeographicBaseline;
    }

    SkScalar getLongestLine()
    {
        return fLongestLine;
    }

    bool didExceedMaxLines()
    {
        return fExceededMaxLines;
    }

    virtual void layout(SkScalar width) = 0;

    virtual void paint(SkCanvas *canvas, SkScalar x, SkScalar y) = 0;

    virtual void paint(ParagraphPainter *painter, SkScalar x, SkScalar y) = 0;

    // Returns a vector of bounding boxes that enclose all text between
    // start and end glyph indexes, including start and excluding end
    virtual std::vector<TextBox> getRectsForRange(unsigned start, unsigned end, RectHeightStyle rectHeightStyle,
        RectWidthStyle rectWidthStyle) = 0;

    virtual std::vector<TextBox> getRectsForPlaceholders() = 0;

    // Returns the index of the glyph that corresponds to the provided coordinate,
    // with the top left corner as the origin, and +y direction as down
    virtual PositionWithAffinity getGlyphPositionAtCoordinate(SkScalar dx, SkScalar dy) = 0;

    // Finds the first and last glyphs that define a word containing
    // the glyph at index offset
    virtual SkRange<size_t> getWordBoundary(unsigned offset) = 0;

    virtual void getLineMetrics(std::vector<LineMetrics> &) = 0;

    virtual size_t lineNumber() = 0;

    virtual void markDirty() = 0;

    // This function will return the number of unresolved glyphs or
    // -1 if not applicable (has not been shaped yet - valid case)
    virtual int32_t unresolvedGlyphs() = 0;
    virtual std::unordered_set<SkUnichar> unresolvedCodepoints() = 0;

    // Experimental API that allows fast way to update some of "immutable" paragraph attributes
    // but not the text itself
    virtual void updateTextAlign(TextAlign textAlign) = 0;
    virtual void updateFontSize(size_t from, size_t to, SkScalar fontSize) = 0;
    virtual void updateForegroundPaint(size_t from, size_t to, SkPaint paint) = 0;
    virtual void updateBackgroundPaint(size_t from, size_t to, SkPaint paint) = 0;

    enum VisitorFlags {
        kWhiteSpace_VisitorFlag = 1 << 0,
    };
    struct VisitorInfo {
        const SkFont &font;
        SkPoint origin;
        SkScalar advanceX;
        int count;
        const uint16_t *glyphs;     // count values
        const SkPoint *positions;   // count values
        const uint32_t *utf8Starts; // count+1 values
        unsigned flags;
    };

    // lineNumber begins at 0. If info is null, this signals the end of that line.
    using Visitor = std::function<void(int lineNumber, const VisitorInfo *)>;
    virtual void visit(const Visitor &) = 0;

    struct ExtendedVisitorInfo {
        const SkFont &font;
        SkPoint origin;
        SkSize advance;
        int count;
        const uint16_t *glyphs;     // count values
        SkPoint *positions;         // count values
        const SkRect *bounds;       // count values
        const uint32_t *utf8Starts; // count+1 values
        unsigned flags;
    };
    using ExtendedVisitor = std::function<void(int lineNumber, const ExtendedVisitorInfo *)>;
    virtual void extendedVisit(const ExtendedVisitor &) = 0;

    /* Returns path for a given line
     *
     * @param lineNumber  a line number
     * @param dest        a resulting path
     * @return            a number glyphs that could not be converted to path
     */
    virtual int getPath(int lineNumber, SkPath *dest) = 0;

    /* Returns path for a text blob
     *
     * @param textBlob    a text blob
     * @return            a path
     */
    static SkPath GetPath(SkTextBlob *textBlob);

    /* Checks if a given text blob contains
     * glyph with emoji
     *
     * @param textBlob    a text blob
     * @return            true if there is such a glyph
     */
    virtual bool containsEmoji(SkTextBlob *textBlob) = 0;

    /* Checks if a given text blob contains colored font or bitmap
     *
     * @param textBlob    a text blob
     * @return            true if there is such a glyph
     */
    virtual bool containsColorFontOrBitmap(SkTextBlob *textBlob) = 0;

    // Editing API

    /* Finds the line number of the line that contains the given UTF-8 index.
     *
     * @param index         a UTF-8 TextIndex into the paragraph
     * @return              the line number the glyph that corresponds to the
     * given codeUnitIndex is in, or -1 if the codeUnitIndex
     * is out of bounds, or when the glyph is truncated or
     * ellipsized away.
     */
    virtual int getLineNumberAt(TextIndex codeUnitIndex) const = 0;

    /* Finds the line number of the line that contains the given UTF-16 index.
     *
     * @param index         a UTF-16 offset into the paragraph
     * @return              the line number the glyph that corresponds to the
     * given codeUnitIndex is in, or -1 if the codeUnitIndex
     * is out of bounds, or when the glyph is truncated or
     * ellipsized away.
     */
    virtual int getLineNumberAtUTF16Offset(size_t codeUnitIndex) = 0;

    /* Returns line metrics info for the line
     *
     * @param lineNumber    a line number
     * @param lineMetrics   an address to return the info (in case of null just skipped)
     * @return              true if the line is found; false if not
     */
    virtual bool getLineMetricsAt(int lineNumber, LineMetrics *lineMetrics) const = 0;

    /* Returns the visible text on the line (excluding a possible ellipsis)
     *
     * @param lineNumber    a line number
     * @param includeSpaces indicates if the whitespaces should be included
     * @return              the range of the text that is shown in the line
     */
    virtual TextRange getActualTextRange(int lineNumber, bool includeSpaces) const = 0;

    struct GlyphClusterInfo {
        SkRect fBounds;
        TextRange fClusterTextRange;
        TextDirection fGlyphClusterPosition;
    };

    /* * Finds a glyph cluster for text index
     *
     * @param codeUnitIndex   a text index
     * @param glyphInfo       a glyph cluster info filled if not null
     * @return                true if glyph cluster was found; false if not
     */
    virtual bool getGlyphClusterAt(TextIndex codeUnitIndex, GlyphClusterInfo *glyphInfo) = 0;

    /* * Finds the closest glyph cluster for a visual text position
     *
     * @param dx              x coordinate
     * @param dy              y coordinate
     * @param glyphInfo       a glyph cluster info filled if not null
     * @return                true if glyph cluster was found; false if not
     * (which usually means the paragraph is empty)
     */
    virtual bool getClosestGlyphClusterAt(SkScalar dx, SkScalar dy, GlyphClusterInfo *glyphInfo) = 0;

    // The glyph and grapheme cluster information assoicated with a unicode
    // codepoint in the paragraph.
    struct GlyphInfo {
        SkRect fGraphemeLayoutBounds;
        TextRange fGraphemeClusterTextRange;
        TextDirection fDirection;
        bool fIsEllipsis;
    };

    /* * Retrives the information associated with the glyph located at the given
     * codeUnitIndex.
     *
     * @param codeUnitIndex   a UTF-16 offset into the paragraph
     * @param glyphInfo       an optional GlyphInfo struct to hold the
     * information associated with the glyph found at the
     * given index
     * @return                false only if the offset is out of bounds
     */
    virtual bool getGlyphInfoAtUTF16Offset(size_t codeUnitIndex, GlyphInfo *glyphInfo) = 0;

    /* * Finds the information associated with the closest glyph to the given
     * paragraph coordinates.
     *
     * @param dx              x coordinate
     * @param dy              y coordinate
     * @param glyphInfo       an optional GlyphInfo struct to hold the
     * information associated with the glyph found. The
     * text indices and text ranges are described using
     * UTF-16 offsets
     * @return                true if a graphme cluster was found; false if not
     * (which usually means the paragraph is empty)
     */
    virtual bool getClosestUTF16GlyphInfoAt(SkScalar dx, SkScalar dy, GlyphInfo *glyphInfo) = 0;

    struct FontInfo {
        FontInfo(const SkFont &font, const TextRange textRange) : fFont(font), fTextRange(textRange) {}
        virtual ~FontInfo() = default;
        FontInfo(const FontInfo &) = default;
        SkFont fFont;
        TextRange fTextRange;
    };

    /* * Returns the font that is used to shape the text at the position
     *
     * @param codeUnitIndex   text index
     * @return                font info or an empty font info if the text is not found
     */
    virtual SkFont getFontAt(TextIndex codeUnitIndex) const = 0;

    /* * Returns the font used to shape the text at the given UTF-16 offset.
     *
     * @param codeUnitIndex   a UTF-16 offset in the paragraph
     * @return                font info or an empty font info if the text is not found
     */
    virtual SkFont getFontAtUTF16Offset(size_t codeUnitIndex) = 0;

    /* * Returns the information about all the fonts used to shape the paragraph text
     *
     * @return                a list of fonts and text ranges
     */
    virtual std::vector<FontInfo> getFonts() const = 0;

protected:
    sk_sp<FontCollection> fFontCollection;
    ParagraphStyle fParagraphStyle;

    // Things for Flutter
    SkScalar fAlphabeticBaseline;
    SkScalar fIdeographicBaseline;
    SkScalar fHeight;
    SkScalar fWidth;
    SkScalar fMaxIntrinsicWidth;
    SkScalar fMinIntrinsicWidth;
    SkScalar fLongestLine;
    bool fExceededMaxLines;
};
} // namespace textlayout
} // namespace skia

#endif // Paragraph_DEFINED
